/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package LogicaNegocio.Validacion;

import LogicaNegocio.Usuarios.Docente;
import LogicaNegocio.Usuarios.Estudiante;
import LogicaNegocio.Usuarios.Usuario;

/**
 * Esta clase en java permite validar datos y atributos correspondientes
 * a los usuarios del sistema BiblioSoft.
 *
 *
 * @author sebaxtian
 * Archivo: VUsuario.java
 * @version 1.0
 * Fecha: mar abr 20 11:03:25 COT 2010
 */


public class VUsuario extends Exception {

    //Atributos de clase
    private Usuario objUsuario;

    /**
     * Crea un objeto validador de usuario que inicializa
     * los atributos a nulos.
     */
    public VUsuario() {
        objUsuario = null;
    }
    /**
     * Crea un objeto validador de usuario que inicializa
     * los atributos a nulos.
     * Como parametro recibe el mensaje de la excepcion.
     *
     * @param nombreExcepcion
     */
    public VUsuario(String mensajeExcepcion) {
        super(mensajeExcepcion);
        objUsuario = null;
    }

    /**
     * Crea un objeto validador de usuario que inicializa
     * los atributos a el objeto que recibe como argumento.
     *
     * @param objUsuario
     * @throws VUsuario
     */
    public VUsuario(Usuario objUsuario) throws VUsuario {
        super("Validador de Usuario");
        this.objUsuario = objUsuario;
        this.validarIdentificacion(objUsuario.getIdentificacionUsuario());
        this.validarPrimerNombre(objUsuario.getPrimerNombre());
        this.validarPrimerApellido(objUsuario.getPrimerApellido());
        this.validarSegundoNombre(objUsuario.getSegundoNombre());
        this.validarSegundoApellido(objUsuario.getSegundoApellido());
        this.validarDireccion(objUsuario.getDireccion());
        this.validarTelefono(objUsuario.getTelefono());
        this.validarEmail(objUsuario.getEmail());
        if(objUsuario.getClass() == Docente.class){
            Docente objDocente = (Docente)objUsuario;
            this.validarDependencia(objDocente.getDependecia());
            this.validarTitulo(objDocente.getTitulo());
            this.validarAreasInteres(objDocente.getAreasInteres());
        }
        if(objUsuario.getClass() == Estudiante.class){
            Estudiante objEstudiante = (Estudiante)objUsuario;
            this.validadCarrera(objEstudiante.getCarrera());
            this.validarUniversidad(objEstudiante.getUniversidad());
        }
    }

    /**
     * Obtiene el usuario que se ingresa como argumento en el constructor.
     *
     * @return objUsuario
     */
    public Usuario getUsuario(){
        return objUsuario;
    }

    /**
     * Este metodo valida la identificacion del usuario,
     * la longitud minima permitida es de 5 digitos y la
     * logintud maxima permitida es de 10 digitos.
     *
     * @param identificacion
     * @throws VUsuario
     */
    public void validarIdentificacion(int identificacion) throws VUsuario {
        String copia = Integer.toString(identificacion);
        if(!copia.matches("[1-9][0-9][0-9]{3,8}")){
            throw new VUsuario("Formato de identificacion : "+identificacion+" : no valido,\n" +
                    "longitud minima permitida es de 5 digitos,\n" +
                    "logintud maxima permitida es de 10 digitos");
        }
    }

    /**
     * Este metodo valida el primer apellido del usuario,
     * la longitud minima permitida es de 3 digitos y la
     * logintud maxima permitida es de 60 digitos.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param primerApellido
     * @throws VUsuario
     */
    public void validarPrimerApellido(String primerApellido) throws VUsuario {
        if(primerApellido == null || !primerApellido.matches("[a-zñA-ZÑ]{3,60}")){
            throw new VUsuario("Formato de primer apellido : "+primerApellido+" : no valido,\n" +
                    "la longitud minima permitida es de 3 digitos,\n" +
                    "logintud maxima permitida es de 60 digitos.\n" +
                    "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
        }
    }

    /**
     * Este metodo valida el segundo apellido del usuario,
     * la longitud minima permitida es de 3 digitos y la
     * logintud maxima permitida es de 60 digitos.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param segundoApellido
     * @throws VUsuario
     */
    public void validarSegundoApellido(String segundoApellido) throws VUsuario {
        if(segundoApellido != null && !segundoApellido.equals("")){
            if(!segundoApellido.matches("[a-zñA-ZÑ]{3,60}")){
                throw new VUsuario("Formato de segundo apellido : "+segundoApellido+" : no valido,\n" +
                        "la longitud minima permitida es de 3 digitos,\n" +
                        "logintud maxima permitida es de 60 digitos.\n" +
                        "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
            }
        }
    }

    /**
     * Este metodo valida el primer nombre del usuario,
     * la longitud minima permitida es de 3 digitos y la
     * logintud maxima permitida es de 60 digitos.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param primerNombre
     * @throws VUsuario
     */
    public void validarPrimerNombre(String primerNombre) throws VUsuario {
        if(primerNombre == null || !primerNombre.matches("[a-zñA-ZÑ]{3,60}")){
            throw new VUsuario("Formato de primer nombre : "+primerNombre+" : no valido,\n" +
                    "la longitud minima permitida es de 3 digitos,\n" +
                    "logintud maxima permitida es de 60 digitos.\n" +
                    "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
        }
    }

    /**
     * Este metodo valida el segundo nombre del usuario,
     * la longitud minima permitida es de 3 digitos y la
     * logintud maxima permitida es de 60 digitos.
     * Solo se permiten caracteres alfabeticos entre mayusculas
     * y minusculas.
     *
     * @param segundoNombre
     * @throws VUsuario
     */
    public void validarSegundoNombre(String segundoNombre) throws VUsuario {
        if(segundoNombre != null && !segundoNombre.equals("") ){
            if(!segundoNombre.matches("[a-zñA-ZÑ]{3,60}")){
                throw new VUsuario("Formato de segundo nombre : "+segundoNombre+" : no valido,\n" +
                        "la longitud minima permitida es de 3 digitos,\n" +
                        "logintud maxima permitida es de 60 digitos.\n" +
                        "Solo se permiten caracteres alfabeticos entre mayusculas y minusculas");
            }
        }
    }

    /**
     * Este metodo valida el formato para las direcciones,
     * las direcciones solo pueden tener el siguente formato:
     *
     * cadena numero+caracter # numero - numero
     *
     * Ejemplos:
     * cra 5 # 12 - 23
     * Calle 6A # 6 - 32
     * Diagonal 23 # 12 - 56
     * cra 12A # 8 - 21
     *
     * @param direccion
     * @throws VUsuario
     */
    public void validarDireccion(String direccion) throws VUsuario {
        if(direccion == null && direccion.length() < 20){
            throw new VUsuario("Formato de direccion : "+direccion+" : no valida,\n" +
                    "el formato de direccion debe ser:\n" +
                    "cadena numero+caracter # numero - numero\n" +
                    "La direccion debe contener maximo 20 caracteres\n" +
                    "Ejemplo:\n" +
                    "cra 5 # 12 - 23\n" +
                    "Calle 6A # 6 - 32");
        }
    }

    /**
     * Este metodo valida el numero de telefono.
     * el numero de telefono es un numero de celular
     * ó telefono fijo.
     *
     * @param telefono
     * @throws VUsuario
     */
    public void validarTelefono(String telefono) throws VUsuario {
        if(telefono == null || !telefono.matches("[1-9][0-9]{6,9}")){
            throw new VUsuario("Formato de telefono : "+telefono+" : no valido,\n" +
                    "el numero de telefono es un numero celular ó\n" +
                    "telefono fijo.");
        }
    }

    /**
     * Este metodo valida que la direccion de correo electronico
     * tenga el formato apropiado.
     * La longitud minima de usuario es 6 la longitud minima de servicio es 4
     * la longitud minima de dominio es 2,
     * la longitud maxima de usuario es 30 la longitud maxima de servicio es 30
     * y la longitud maxima de dominio es 6.
     *
     * usuario@servicio.dominio
     * Ejemplo:
     * sebaxtian@estudiante.co
     *
     * @param email
     * @throws VUsuario
     */
    public void validarEmail(String email) throws VUsuario {
        if(email != null){//"^.|^@""^www.""@""[^A-Za-z0-9.@_-~#]+"
            if(!email.matches("[a-z_A-Z0-9]{6,30}[@][a-zA-Z]{4,30}[.][a-z]{2,6}")){
                throw new VUsuario("Formato de email : "+email+" : no valido,\n" +
                        "el email debe tener un formato valido,\n" +
                        "usuario@servicio.dominio\n" +
                        "La longitud minima de usuario es 6 la longitud minima de servicio es 4\n" +
                        "la longitud minima de dominio es 2,\n" +
                        "la longitud maxima de usuario es 30 la longitud maxima de servicio es 30\n" +
                        "y la longitud maxima de dominio es 6.\n" +
                        "Ejemplo:\n" +
                        "sebaxtian@estudiante.co");
            }
        }
    }

    /**
     * Este metodo valida el formato para la dependencia,
     * solo puede contener caracteres alfabeticos, con una logitud
     * minima de 8 caracteres y una longitud maxima de 60 caracteres.
     *
     * @param dependencia
     * @throws VUsuario
     */
    public void validarDependencia(String dependencia) throws VUsuario {
        if(dependencia == null || !dependencia.matches("[a-zñ A-ZÑ]{8,60}")){
            throw new VUsuario("Formato de dependencia : "+dependencia+" : no valido,\n" +
                    "la dependencia solo debe contener caracteres alfabeticos,\n" +
                    "la longitud minima es de 8 caracteres y la longitud maxima\n" +
                    "es de 60 caracteres.");
        }
    }

    /**
     * Este metodo valida el formato para el titulo,
     * solo puede contener caracteres alfabeticos, con una logitud
     * minima de 8 caracteres y una longitud maxima de 30 caracteres.
     *
     * @param titulo
     * @throws VUsuario
     */
    public void validarTitulo(String titulo) throws VUsuario {
        if(titulo == null || !titulo.matches("[a-zñ A-ZÑ]{8,60}")){
            throw new VUsuario("Formato de titulo : "+titulo+" : no valido,\n" +
                    "el titulo solo debe contener caracteres alfabeticos,\n" +
                    "la longitud minima es de 8 caracteres y la longitud maxima\n" +
                    "es de 60 caracteres.");
        }
    }

    /**
     * Este metodo valida el formato para las areas de interes
     * las areas de interes debe estar separadas por el caracter [,]
     * la longitud minima para un area de interes es de 3 caracteres,
     * la longitud maxima para un area de interes es de 200 caracteres.
     *
     * @param areasInteres
     * @throws VUsuario
     */
    public void validarAreasInteres(String areasInteres) throws VUsuario {
        if(areasInteres == null || !areasInteres.matches("[[a-zñ A-ZÑ]{3,200}[,]]*[a-zñ A-ZÑ]{3,200}")){
            System.out.println("Areas de interes : "+areasInteres+" : VALIDAS");
            throw new VUsuario("Formato de areas de interes : "+areasInteres+" : no valido,\n" +
                    "las areas de interes deben estar separadas por el caracter [,]\n" +
                    "la longitud minima para un area de interes es de 3 caracteres,\n" +
                    "la longitud maxima para un area de interes es de 200 caracteres.\n" +
                    "solo debe contener caracteres alfabeticos y espacios.");
        }
    }

    /**
     * Este metodo valida el formato para la carrera
     * solo se permiten caracteres alfabeticos con longitud minima
     * de 3 caracteres y longitud maxima de 60 caracteres.
     * 
     * @param carrera
     * @throws VUsuario
     */
    public void validadCarrera(String carrera) throws VUsuario {
        if(carrera == null || !carrera.matches("[a-zñ A-ZÑ]{3,60}")){
            throw new VUsuario("Formato de carrera : "+carrera+" : no valido,\n" +
                    "solo se permiten caracteres alfabeticos con longitud minima\n" +
                    "de 3 caracteres y longitud maxima de 60 caracteres.");
        }
    }

    /**
     * Este metodo valida el formato para la universidad
     * solo se permiten caracteres alfabeticos con longitud minima
     * de 3 caracteres y longitud maxima de 60 caracteres.
     *
     * @param universidad
     * @throws VUsuario
     */
    public void validarUniversidad(String universidad) throws VUsuario {
        if(universidad == null || !universidad.matches("[a-zñ A-ZÑ]{3,60}")){
            throw new VUsuario("Formato de universidad : "+universidad+" : no valido,\n" +
                    "solo se permiten caracteres alfabeticos con longitud minima\n" +
                    "de 3 caracteres y longitud maxima de 60 caracteres.");
        }
    }
}
